home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Utilities / CommentConverter 1.0.0 / Think C 7.0 Project / Sources / ⁄⁄<->⁄**⁄.c next >
Encoding:
C/C++ Source or Header  |  1993-12-31  |  10.2 KB  |  386 lines  |  [TEXT/KAHL]
  1. //FEHLER:
  2. //- WENN DER FILENAME NICHT RICHTIG IST KOMMT ZWAR DIE MESSAGE, ABER ES WIRD TROTZDEM GEMACHT
  3. //- EOF WIRD GESCHRIEBEN!
  4. //- Beide behoben, NOCHMAL AN ALLEN FILES TESTEN!!!!!
  5. /******************************************************************************/
  6. /******************************************************************************/
  7. /******************************************************************************/
  8. /** Modul-Name            : sorry, that´s impossible.C                            **/
  9. /** Autor                : A. Amoroso                                          **/
  10. /** Funktion            : New 2 Old Style Comments                             **/
  11. /** Datum                : 6.12.1993                                              **/
  12. /******************************************************************************/
  13. /******************************************************************************/
  14. /******************************************************************************/
  15.  
  16. #include <ctype.h>
  17. #include <fcntl.h>
  18. #include <float.h>
  19. #include <limits.h>
  20. #include <math.h>
  21. #include <size_t.h>
  22. #include <stat.h>
  23. #include <stdarg.h>
  24. #include <time.h>
  25.  
  26. #include <string.h>
  27. #include <stdlib.h>
  28. #include <stdio.h>
  29. #include <GestaltEqu.h>
  30. #include <Files.h>
  31. #include <TextEdit.h>
  32. #include <Dialogs.h>
  33. #include <types.h>
  34. #include <pascal.h>
  35. #include <Events.h>
  36. #include <EPPC.h>
  37. #include <AppleEvents.h>
  38. #include <OSEvents.h>
  39.  
  40.  
  41. #include "Apple.h"
  42. #include "Help.h"
  43.  
  44. #include "//<->/**/.h"
  45.  
  46. #ifdef testme
  47. #include <console.h>
  48. #endif
  49.  
  50. /******************************************************************************/
  51. /* Hauptprogramm                                  */
  52. /******************************************************************************/
  53.  
  54. int main(int argc, char *argv[])
  55.  
  56. {
  57.     char     NName[MaxFullPathName+1],
  58.             OName[MaxFullPathName+1],
  59.             *occur = NULL,
  60.             option = 0,
  61.             stop = 0,            
  62.             c1 = 0,
  63.             c2 = 0,
  64.             c = 0,
  65.             cbuf = 0,
  66.             q1 = 0,
  67.             q2 = 0;
  68.     int     i = 0,
  69.             len = 0;
  70.     long int
  71.             filepos = 0L;
  72.     unsigned long
  73.             typ = 0,
  74.             cre = 0;
  75.     FILE    *Optr = NULL,
  76.             *Nptr = NULL;
  77.     
  78.  
  79. #ifdef apple
  80. #ifndef testme
  81.     argv = GetProgParams(&argc);
  82.     occur = strrchr(*argv, ':');
  83.     option = (NULL != strstr((const char *)occur, "o"));
  84. //    printf("Occur: %s\n", occur);
  85. //    if (NULL != strstr((const char *)occur, "o"))
  86. //        printf("Ergebnis Suche nach o: %s\n", strstr((const char *)occur, "o"));
  87. //    printf ("Option: %i\n ARGV: %s", option, *argv);
  88.  
  89.  
  90. //    Nptr = fopen("Modifiers.txt","w");
  91. //    fputs(occur,Nptr);
  92. //    fclose(Nptr);
  93. #endif
  94. #endif /* apple */
  95. #ifdef testme
  96.     argc = ccommand(&argv);
  97.     option = 0;
  98. #endif
  99.     
  100.     if (option){
  101.         for(i=1; i < argc; i++){
  102.             NName[0] = OName[0] = stop = c1 = c2 = c = q1 = q2 = 0;
  103.             len = 0;
  104.             Optr = NULL;
  105.             Nptr = NULL;
  106.             stop = 0;
  107.             c = 0;
  108.             cbuf = 0;
  109.             q1 = q2 = 0;
  110.             filepos = 0L;
  111.             strcpy((char *)NName, (const char *)*(argv+i));
  112.             strcpy((char *)OName, (const char *)*(argv+i));
  113.             len = (int)strlen((const char *)NName);
  114.             if ((c2 = *(OName + len - 2)) != '.')
  115.                 HandleError(NoCFile); 
  116.             if ((c1 = *(OName + len - 1)) == 'c')
  117.                 *(NName + len - 1) = 'b';
  118.                 else if (c1 == 'C')
  119.                     *(NName + len - 1) = 'B';
  120.                     else if (c1 == 'h')
  121.                         *(NName + len - 1) = 'g';
  122.                         else if (c1 == 'H')
  123.                             *(NName + len - 1) = 'G';
  124.             if ((c1 != 'c') && (c1 != 'C') && (c1 != 'h') && (c1 != 'H'))
  125.                 HandleError(NoCFile); 
  126.             Optr = fopen(OName, "r");
  127.             if (Optr == NULL)
  128.                 HandleError(FileIO);
  129.             Nptr = fopen(NName, "w");
  130.             if (Nptr == NULL)
  131.                 HandleError(FileIO);
  132.     /* Folgende while Schleifen sind kommentar erkennender automat, 4 zustaende, 4 Eingaben */
  133.             if (EOF != (c = fgetc(Optr)))
  134.                 do{
  135.                     switch(q1){
  136.                         case 0: switch (q2){
  137.                                     case 0:    switch (c){
  138.                                                 case SL:    q1 = 1;
  139.                                                             q2 = 0;
  140.                                                             break;
  141.                                                 case EOF:    stop = 1;
  142.                                                 case CR:    /*break, the same...*/;
  143.                                                 default:    q1 = 0;
  144.                                                             q2 = 0;
  145.                                                             if (c != EOF)
  146.                                                                 if (EOF == fputc(c,Nptr))
  147.                                                                     HandleError(FileIO);
  148.                                                             break;
  149.                                             }
  150.                                             break;
  151.                                     case 1:    switch (c){
  152.                                                 case EOF:    stop = 1;
  153.                                                 case CR:    q1 = 0;
  154.                                                             q2 = 0;
  155.                                                             if (EOF == fputs("*/\n",Nptr))
  156.                                                                 HandleError(FileIO);
  157.                                                             break;
  158.                                                 case SL:    /*break, the same...*/;
  159.                                                 default:    q1 = 0;
  160.                                                             q2 = 1;
  161.                                                             if (c != EOF)
  162.                                                                 if (EOF == fputc(c,Nptr))
  163.                                                                     HandleError(FileIO);
  164.                                                             break;
  165.                                             }
  166.                                             break;
  167.                                 }
  168.                                 break;
  169.                         case 1: switch (q2){
  170.                                     case 0:    switch (c){
  171.                                                 case SL:    q1 = 0;
  172.                                                             q2 = 1;
  173.                                                             if (EOF == fputs("/*",Nptr))
  174.                                                                 HandleError(FileIO);
  175.                                                             break;
  176.                                                 case EOF:    stop = 1;
  177.                                                 case CR:    /*break, the same...*/;
  178.                                                 default:    q1 = 0;
  179.                                                             q2 = 0;
  180.                                                             if (EOF == fputs("/",Nptr))
  181.                                                                 HandleError(FileIO);
  182.                                                             if (c != EOF)
  183.                                                                 if (EOF == fputc(c,Nptr))
  184.                                                                     HandleError(FileIO);
  185.                                                             break;
  186.                                             }    
  187.                                             break;
  188.                                     case 1:    switch (c){
  189.                                                 case EOF:    stop = 1;
  190.                                                 case SL:    /*break, the same...*/;
  191.                                                 case CR:    /*break, the same...*/;
  192.                                                 default:    q1 = 0;
  193.                                                             q2 = 0;
  194.                                                             HandleError(IllState);
  195.                                                             break;
  196.                                             }
  197.                                             break;
  198.                                 }
  199.                                 break;
  200.                     }
  201.                     if (!stop)
  202.                         c = fgetc(Optr);
  203.                 }while (!stop);
  204.         if (EOF == fclose(Optr))
  205.             HandleError(FileIO);
  206.         if (EOF == fclose(Nptr))
  207.             HandleError(FileIO);
  208.             GetFileInfo(OName,&typ,&cre);
  209.             SetFileInfo(NName,typ,cre);
  210.             GetFileInfo(OName,&typ,&cre); // Soll den Finder veranlassen das neue Icon zu zeigen...
  211.     //        SetFileInfo(NName,'TEXT','KAHL');
  212.         }
  213.     }
  214.     
  215.     
  216.     else if (!option){
  217.         for(i=1; i < argc; i++){
  218.             NName[0] = OName[0] = stop = c1 = c2 = c = q1 = q2 = 0;
  219.             len = 0;
  220.             Optr = NULL;
  221.             Nptr = NULL;
  222.             stop = 0;
  223.             c = 0;
  224.             cbuf = 0;
  225.             filepos = 0L;
  226.             q1 = q2 = 0;
  227.             strcpy((char *)NName, (const char *)*(argv+i));
  228.             strcpy((char *)OName, (const char *)*(argv+i));
  229.             len = (int)strlen((const char *)NName);
  230.             if ((c2 = *(OName + len - 2)) != '.')
  231.                 HandleError(NoCFile); 
  232.             if ((c1 = *(OName + len - 1)) == 'c')
  233.                 *(NName + len - 1) = 'd';
  234.                 else if (c1 == 'C')
  235.                     *(NName + len - 1) = 'D';
  236.                     else if (c1 == 'h')
  237.                         *(NName + len - 1) = 'i';
  238.                         else if (c1 == 'H')
  239.                             *(NName + len - 1) = 'I';
  240.             if ((c1 != 'c') && (c1 != 'C') && (c1 != 'h') && (c1 != 'H'))
  241.                 HandleError(NoCFile); 
  242.             Optr = fopen(OName, "r");
  243.             if (Optr == NULL)
  244.                 HandleError(FileIO);
  245.             Nptr = fopen(NName, "w");
  246.             if (Nptr == NULL)
  247.                 HandleError(FileIO);
  248.     /* Folgende while Schleifen sind kommentar erkennender automat, 4 zustaende, 4 Eingaben */
  249.             if (EOF != (c = fgetc(Optr)))
  250.                 do{
  251.                     switch(q1){
  252.                         case 0: switch (q2){
  253.                                     case 0:    switch (c){
  254.                                                 case SL:    q1 = 1;
  255.                                                             q2 = 0;
  256.                                                             break;
  257.                                                 case EOF:    stop = 1;
  258.                                                 case CR:    /*break, the same...*/;
  259.                                                 case ST:    /*break, the same...*/;
  260.                                                 default:    q1 = 0;
  261.                                                             q2 = 0;
  262.                                                             if (c != EOF)
  263.                                                                 if (EOF == fputc(c,Nptr))
  264.                                                                     HandleError(FileIO);
  265.                                                             break;
  266.                                             }
  267.                                             break;
  268.                                     case 1:    switch (c){
  269.                                                 case CR:    q1 = 0;
  270.                                                             q2 = 1;
  271.                                                             if (EOF == fputs("\n//",Nptr))
  272.                                                                 HandleError(FileIO);
  273.                                                             break;
  274.                                                 case ST:    q1 = 1;
  275.                                                             q2 = 1;
  276.                                                             break;            
  277.                                                 case EOF:    stop = 1;
  278.                                                 case SL:    /*break, the same...*/;
  279.                                                 default:    q1 = 0;
  280.                                                             q2 = 1;
  281.                                                             if (c != EOF)
  282.                                                                 if (EOF == fputc(c,Nptr))
  283.                                                                     HandleError(FileIO);
  284.                                                             break;
  285.                                             }
  286.                                             break;
  287.                                 }
  288.                                 break;
  289.                         case 1: switch (q2){
  290.                                     case 0:    switch (c){
  291.                                                 case ST:    q1 = 0;
  292.                                                             q2 = 1;
  293.                                                             if (EOF == fputs("//",Nptr))
  294.                                                                 HandleError(FileIO);
  295.                                                             break;
  296.                                                 case EOF:    stop = 1;
  297.                                                 case CR:    /*break, the same...*/;
  298.                                                 case SL:    /*break, the same...*/;
  299.                                                 default:    q1 = 0;
  300.                                                             q2 = 0;
  301.                                                             if (EOF == fputs("/",Nptr))
  302.                                                                 HandleError(FileIO);
  303.                                                             if (c != EOF)
  304.                                                                 if (EOF == fputc(c,Nptr))
  305.                                                                     HandleError(FileIO);
  306.                                                             break;
  307.                                             }    
  308.                                             break;
  309.                                     case 1:    switch (c){
  310.                                                 case SL:    q1 = 0;
  311.                                                             q2 = 0;
  312.                                                             {
  313.                                                                 filepos = ftell(Optr);
  314.                                                                 while (CR != (c = fgetc(Optr))){
  315.                                                                     if (isalpha(c))
  316.                                                                         cbuf = 1; /* Jawoll, Return ausgeben! */
  317.                                                                 }
  318.                                                                 if(fseek(Optr, filepos, SEEK_SET))
  319.                                                                     HandleError(FileIO);
  320.                                                                 if (cbuf){
  321.                                                                     if (EOF == fputs("\n",Nptr))
  322.                                                                         HandleError(FileIO);
  323.                                                                     cbuf = 0;
  324.                                                                 }
  325.                                                             }
  326.                                                             break;
  327.                                                 case ST:    q1 = 1;
  328.                                                             q2 = 1;
  329.                                                             if (EOF == fputs("*",Nptr))
  330.                                                                 HandleError(FileIO);
  331.                                                             break;
  332.                                                 case EOF:    stop = 1;
  333.                                                 case CR:    /*break, the same...*/;
  334.                                                 default:    q1 = 0;
  335.                                                             q2 = 1;
  336.                                                             if (EOF == fputs("*",Nptr))
  337.                                                                 HandleError(FileIO);
  338.                                                             if (c != EOF)
  339.                                                                 if (EOF == fputc(c,Nptr))
  340.                                                                     HandleError(FileIO);
  341.                                                             break;
  342.                                             }
  343.                                             break;
  344.                                 }
  345.                                 break;
  346.                     }
  347.                     if (!stop)
  348.                         c = fgetc(Optr);
  349.                 }while (!stop);
  350.         if (EOF == fclose(Optr))
  351.             HandleError(FileIO);
  352.         if (EOF == fclose(Nptr))
  353.             HandleError(FileIO);
  354.             GetFileInfo(OName,&typ,&cre);
  355.             SetFileInfo(NName,typ,cre);
  356.             GetFileInfo(OName,&typ,&cre); // Soll den Finder veranlassen das neue Icon zu zeigen...
  357.     //        SetFileInfo(NName,'TEXT','KAHL');
  358.         }
  359.     }
  360.     GenExit(0);
  361. }
  362.  
  363. void HandleError(int error)
  364. {
  365.     short itemHit = 0;
  366.     
  367.     switch(error){
  368.         case    1:    do
  369.                     {
  370.                         itemHit = StopAlert(rNoCFile,nil);
  371.                     }while(itemHit != dOKButton);
  372.                       break;
  373.           case    2:    do
  374.                     {
  375.                         itemHit = StopAlert(rFileIO,nil);
  376.                     }while(itemHit != dOKButton);
  377.                       break;
  378.           case    3:    do
  379.                     {
  380.                         itemHit = StopAlert(rIllState,nil);
  381.                     }while(itemHit != dOKButton);
  382.                       break;
  383.           default:    GenExit(0);
  384.     }
  385.     GenExit(0);
  386. }